home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / iguana / vts139b / lib / loader66.pas < prev    next >
Pascal/Delphi Source File  |  1993-11-25  |  9KB  |  364 lines
  1. UNIT Loader669;
  2.  
  3. INTERFACE
  4.  
  5. USES Objects, SongUnit;
  6.  
  7.  
  8.  
  9.  
  10. PROCEDURE Load669FileFormat  (VAR Song: TSong; VAR St: TStream; VAR Header: TSongHeader);
  11.  
  12.  
  13.  
  14.  
  15. IMPLEMENTATION
  16.  
  17. USES SongElements, SongUtils, Heaps, AsciiZ;
  18.  
  19.  
  20.  
  21.  
  22. {----------------------------------------------------------------------------}
  23. { Internal definitions. Format of the files.                                 }
  24. {____________________________________________________________________________}
  25.  
  26. TYPE
  27.   T669FileMagic = WORD;
  28.  
  29. CONST
  30.   Magic669 = $6669;
  31.  
  32. TYPE
  33.  
  34.   TSizes = ARRAY[1..128] OF BYTE;
  35.  
  36.   T669Header =
  37.     RECORD
  38.       Magic       : T669FileMagic;
  39.       Comment     : ARRAY[1..3, 1..36] OF CHAR;
  40.       NInstruments: BYTE;
  41.       NPatterns   : BYTE;
  42.       RepStart    : BYTE;
  43.       Sequence    : TSizes;
  44.       Tempos      : TSizes;
  45.       Lengths     : TSizes;
  46.     END;
  47.  
  48.   T669Instrument =
  49.     RECORD
  50.       Name      : ARRAY[1..13] OF CHAR;
  51.       Size      : LONGINT;
  52.       RepStart  : LONGINT;
  53.       RepLen    : LONGINT;
  54.     END;
  55.  
  56.   T669Pattern = ARRAY[1..64, 1..8] OF
  57.     RECORD
  58.       CASE BYTE OF
  59.         0 : ( w1 : WORD;
  60.               b  : BYTE );
  61.         1 : ( b1,
  62.               b2,
  63.               b3 : BYTE );
  64.     END;
  65.  
  66.  
  67.  
  68.  
  69. PROCEDURE ProcessPatterns(VAR Song: TSong; VAR St: TStream; VAR Sizes: TSizes; Num: WORD; Tempos: TSizes);
  70.   VAR
  71.     Patt      : T669Pattern;
  72.     FullTrack : TFullTrack;
  73.     Pattern   : PPattern;
  74.     Track     : PTrack;
  75.     Note      : TFullNote;
  76.     c         : BYTE;
  77.     i, j      : WORD;
  78.     n, t      : WORD;
  79.     Row       : WORD;
  80.     Size      : WORD;
  81.     NAdj      : WORD;
  82.     l         : LONGINT;
  83.   BEGIN
  84.     t := 1;
  85.     FOR n := 1 TO Num DO
  86.       BEGIN
  87.         Pattern := Song.GetPattern(n);
  88.         IF Pattern = NIL THEN
  89.           BEGIN
  90.             Song.Status := msOutOfMemory;
  91.             EXIT;
  92.           END;
  93.  
  94.         WITH Pattern^.Patt^ DO
  95.           BEGIN
  96.             NNotes := Sizes[n] + 1;
  97.             NChans := Song.NumChannels;
  98.             Tempo  := Tempos[n];
  99.             BPM    := 0;
  100.           END;
  101.  
  102.         St.Read(Patt, SizeOf(Patt));
  103.  
  104.         IF St.Status <> stOk THEN
  105.           BEGIN
  106.             Song.Status := msFileTooShort;
  107.             EXIT;
  108.           END;
  109.  
  110.         FOR j := 1 TO Song.NumChannels DO
  111.           BEGIN
  112.             FillChar(FullTrack, SizeOf(FullTrack), 0);
  113.  
  114.             FOR i := 1 TO 64 DO
  115.               WITH FullTrack[i-1], Patt[i][j] DO
  116.                 BEGIN
  117.                   IF b1 < $FE THEN
  118.                     BEGIN
  119.                       Period     := PeriodArray[b1 SHR 2];
  120.                       Instrument := ((SWAP(w1) SHR 4) AND 63) + 1;
  121.                     END;
  122.  
  123.                   IF b1 < $FF THEN
  124.                     Volume   := ((b2 AND 15) SHL 2) + ((b2 AND 15) SHR 2) + 1;
  125.  
  126.                   Parameter  := b3 AND 15;
  127.                   Command    := mcNone;
  128.  
  129.                   IF Parameter <> 0 THEN
  130.                     CASE b3 SHR 4 OF
  131.                       0 : Command := mcTPortUp;
  132.                       1 : Command := mcTPortDown;
  133.                       2 : Command := mcNPortamento;
  134.                       3 : INC(Period);
  135.                       4 : BEGIN
  136.                             Command   := mcVibrato;
  137.                             Parameter := (Parameter SHL 4) + 1
  138.                           END;
  139.                       5 : Command := mcSetTempo;
  140.                     END;
  141.                 END;
  142.  
  143.             Track := Song.GetTrack(t);
  144.             IF Track = NIL THEN
  145.               BEGIN
  146.                 Song.Status := msOutOfMemory;
  147.                 EXIT;
  148.               END;
  149.  
  150.             Track^.SetFullTrack(FullTrack);
  151.  
  152.             Pattern^.Patt^.Channels[j] := t;
  153.  
  154.             INC(t);
  155.           END;
  156.  
  157.       END;
  158.   END;
  159.  
  160.  
  161. PROCEDURE ProcessInstruments(VAR Song: TSong; VAR St: TStream; Num: WORD);
  162.   VAR
  163.     Instrument : TInstrumentRec;
  164.     Instr      : PInstrument;
  165.     Instr669   : T669Instrument;
  166.     i, w       : WORD;
  167.     Signo      : LONGINT;
  168.     NoSigno    : LONGINT;
  169.   BEGIN
  170.     FOR i := 1 TO Num DO
  171.       WITH Instrument DO
  172.         BEGIN
  173.           FillChar(Instrument, SizeOf(Instrument), 0);
  174.  
  175.           Instr := Song.GetInstrument(i);
  176.           IF Instr = NIL THEN
  177.             BEGIN
  178.               Song.Status := msOutOfMemory;
  179.               EXIT;
  180.             END;
  181.  
  182.           St.Read(Instr669, SizeOf(Instr669));
  183.  
  184.           Instr^.SetName(StrASCIIZ(Instr669.Name, 13));
  185.  
  186.           Len  := Instr669.Size;
  187.  
  188.           IF Len > 0 THEN
  189.             BEGIN
  190.  
  191.               IF Instr669.RepLen <= Len THEN
  192.                 BEGIN
  193.                   Reps := Instr669.RepStart;
  194.                   Repl := Instr669.RepLen;
  195.                 END
  196.               ELSE
  197.                 BEGIN
  198.                   Reps := 0;
  199.                   Repl := 0;
  200.                 END;
  201.  
  202.               Vol  := 64;
  203.  
  204.               IF Repl        > Len THEN Repl := Len;
  205.               IF Reps + Repl > Len THEN Repl := Len - Reps;
  206.  
  207.  
  208.               Instr^.Change(@Instrument);
  209.             END
  210.           ELSE
  211.             Instr^.Change(NIL);
  212.         END;
  213.   END;
  214.  
  215.  
  216.  
  217. PROCEDURE ProcessSamples(VAR Song: TSong; VAR St: TStream; Num: WORD);
  218.   VAR
  219.     Instr      : PInstrument;
  220.     Instrument : TInstrumentRec;
  221.     i, w       : WORD;
  222.     l          : LONGINT;
  223.   BEGIN
  224.     FOR i := 1 TO Num DO
  225.       BEGIN
  226.         Instr := Song.GetInstrument(i);
  227.  
  228.         IF (Instr^.Instr     <> NIL) AND
  229.            (Instr^.Instr^.Len > 0)   THEN
  230.           BEGIN
  231.             Move(Instr^.Instr^, Instrument, SizeOf(Instrument));
  232.             Instr^.FreeContents;
  233.  
  234.             WITH Instrument DO
  235.               BEGIN
  236.  
  237.                 l := St.GetPos;
  238.                 l := St.GetSize - l;
  239.                 IF Len > l THEN
  240.                   BEGIN
  241.                     Song.Status := msFileTooShort;
  242.                     Len := l;
  243.                   END;
  244.  
  245.                 l := St.GetPos + Len;
  246.  
  247.                 IF Len > 0 THEN
  248.                   BEGIN
  249.                     IF Len <= MaxSample THEN
  250.                       BEGIN
  251.                         FullHeap.HGetMem(POINTER(Data), Len);
  252.                         IF Data = NIL THEN BEGIN
  253.                           Song.Status := msOutOfMemory;
  254.                           EXIT;
  255.                         END;
  256.  
  257.                         St.Read(Data^, Len);
  258.  
  259.                         IF St.Status <> stOk THEN BEGIN
  260.                           Song.Status := msFileDamaged;
  261.                           EXIT;
  262.                         END;
  263.  
  264.                         FOR w := 0 TO Len - 1 DO
  265.                           INC(Data^[w], 128);
  266.                       END
  267.                     ELSE
  268.                       BEGIN
  269.                         FullHeap.HGetMem(POINTER(Data), MaxSample);
  270.                         FullHeap.HGetMem(POINTER(Xtra), Len-MaxSample);
  271.  
  272.                         IF (Data = NIL) OR (Xtra = NIL) THEN BEGIN
  273.                           Song.Status := msOutOfMemory;
  274.                           EXIT;
  275.                         END;
  276.  
  277.                         St.Read(Data^, MaxSample);
  278.                         St.Read(Xtra^, Len-MaxSample);
  279.  
  280.                         IF St.Status <> 0 THEN BEGIN
  281.                           Song.Status := msFileDamaged;
  282.                           EXIT;
  283.                         END;
  284.                       END;
  285.                   END;
  286.                 St.Seek(l);
  287.               END;
  288.             Instr^.Change(@Instrument);
  289.           END;
  290.  
  291.         IF LowQuality THEN
  292.           Instr^.Desample;
  293.  
  294.       END;
  295.   END;
  296.  
  297. PROCEDURE Load669FileFormat(VAR Song: TSong; VAR St: TStream; VAR Header: TSongHeader);
  298.   VAR
  299.     Hdr        : T669Header ABSOLUTE Header;
  300.     InitialPos : LONGINT;
  301.     i          : WORD;
  302.   BEGIN
  303.     Song.FileFormat := mffComposer669;
  304.  
  305.     InitialPos := St.GetPos;
  306.  
  307.     St.Seek(InitialPos + SizeOf(T669Header));
  308.  
  309.     IF Hdr.Magic <> Magic669 THEN
  310.       BEGIN
  311.         Song.Status := msNotLoaded;
  312.         EXIT;
  313.       END;
  314.  
  315.     Song.Status := msOK;
  316.  
  317.     Song.Name := FullHeap.HNewStr(Song.FileName);
  318.  
  319.     Song.InitialTempo := 4;
  320.     Song.InitialBPM   := 80;
  321.     Song.Volume       := 255;
  322.     Song.NumChannels  := 8;
  323.  
  324.     Song.SequenceLength := 0;
  325.     FOR i := 1 TO 128 DO
  326.       IF Hdr.Sequence[i] < 128 THEN
  327.         Song.SequenceLength := i;
  328.  
  329.     Song.SequenceRepStart := Hdr.RepStart + 1;
  330.     Move(Hdr.Sequence, Song.PatternSequence^, Song.SequenceLength);
  331.  
  332.     FOR i := 1 TO Song.SequenceLength DO
  333.       INC(Song.PatternSequence^[i]);
  334.  
  335.     FOR i := 1 TO MaxChannels DO
  336.       IF Odd(i) THEN
  337.         Song.PanPositions[i] := $B0
  338.       ELSE
  339.         Song.PanPositions[i] := $40;
  340.  
  341.  
  342.     { Processing of the instruments }
  343.  
  344.     ProcessInstruments(Song, St, Hdr.NInstruments);
  345.     IF Song.Status > msOk THEN EXIT;
  346.  
  347.  
  348.     { Processing of the patterns (the partiture) }
  349.  
  350.     ProcessPatterns(Song, St, Hdr.Lengths, Hdr.NPatterns, Hdr.Tempos);
  351.     IF Song.Status > msOk THEN EXIT;
  352.  
  353.  
  354.     { Processing of the samples }
  355.  
  356.     ProcessSamples(Song, St, Hdr.NInstruments);
  357.     IF Song.Status > msFileTooShort THEN EXIT;
  358.   END;
  359.  
  360.  
  361.  
  362.  
  363. END.
  364.